/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package op;

import java.util.Calendar;
import java.util.Date;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * @author Jonatas
 */
public class QuebraStringOI {

    public static Pattern telefone = Pattern.compile("[0-9]{4}-[0-9]{4}");
    public static Pattern tempo = Pattern.compile("[0-9]{2}:[0-9]{2}:[0-9]{2}");
//    private static Pattern data = Pattern.compile("\\d\\d[\\]\\d\\d[\\][\\d]{4}");
    public static Pattern outrasCobrancas = Pattern.compile("[0-9]{4}-[0-9]{4}[ ]+"
            + "[0-9]{2}:[0-9]{2}:[0-9]{2}[ ]+[0-9]{2}:[0-9]{2}:[0-9]{2}");
    public static Pattern outrasCobrancasFixo = Pattern.compile("[0-9]{2}[ ]+[0-9]{4}-[0-9]{4}[ ]+"
            + "[0-9]{2}:[0-9]{2}:[0-9]{2}[ ]+([0-9]{2}:[0-9]{2}:[0-9]{2}|[0-9]{4}:[0-9]{2})");
    public static Pattern valor = Pattern.compile("-?[0-9]+[,][0-9]{2}");

    public static EntradaAbstrata quebraStringOIContaTotal(String entrada, Telefone numeroDeOrigem, String tipoLigacao, boolean aCobrar) {

        /******************************************************************************/
        Pattern telefone = Pattern.compile("\\d{10}");
        Pattern outrosTelefones = Pattern.compile("[*]\\d{3}");
        Pattern data = Pattern.compile("[0-9]{2}/[0-9]{2}/[0-9]{4}");
        Pattern custo = Pattern.compile("[0-9]+[,][ ]?[0-9]{2}");
        /******************************************************************************/
        EntradaAbstrata resposta = null;

        entrada = entrada.trim();

        boolean isLigacao = false;

        Telefone destino = null;

        int inicioPlano = -1;

        Matcher matchTempo = QuebraStringTIM.hora.matcher(entrada);
        // outras cobrancas

        int pontoTempo = 22;

        if (entrada.contains("Serviço 0300")) {
            pontoTempo = 50;
        }

        if (entrada.length() < 30 || !matchTempo.find(pontoTempo)) {

            resposta = new OutrasCobrancas();

            resposta.setDuracaoLigacaoSegundos(null);

            Matcher matcher = telefone.matcher(entrada.substring(10));
            if (matcher.find()) {
                String foneStr = null;

                foneStr = matcher.group();


                destino = new Telefone("0" + foneStr);
            } else {

                matcher = outrosTelefones.matcher(entrada.substring(10));
                if (matcher.find()) {
                    destino = new Telefone(matcher.group());
                } else {
                    destino = null;
                }
            }

        } else { // É ligação

            isLigacao = true;
            resposta = new Ligacao();
            String tipo = null;

            int inicioDescricao = -1;
            int fimDescricao = -1;

            Matcher matcher = telefone.matcher(entrada);

            if (entrada.contains("Serviço 0300")) {
                Pattern p0300 = Pattern.compile("0300[0-9]{7}");
                matcher = p0300.matcher(entrada);
                boolean b = matcher.find(11);

                if (!b) {
                    p0300 = Pattern.compile("300[0-9]{7}");
                    matcher = p0300.matcher(entrada);
                    b = matcher.find(11);
                }

                inicioDescricao = matcher.end();

                destino = new Telefone(matcher.group(), true);

            } else if (matcher.find(11)) {
                String foneStr = null;
                try {
                    foneStr = matcher.group();
                } catch (Exception e) {
                    e.printStackTrace();
                }

                inicioDescricao = matcher.end();
                destino = new Telefone(("0" + foneStr));
            } else if (entrada.contains("102 NACIONAL")) {
                inicioDescricao = entrada.indexOf("102") + 3;
                destino = new Telefone("102", true);
            } else {

                matcher = outrosTelefones.matcher(entrada);
                if (matcher.find(11)) {
                    destino = new Telefone(matcher.group());
                    inicioDescricao = matcher.end();
                } else {
                    destino = null;
                }
            }

            matcher = tempo.matcher(entrada);

            matcher.find();

            fimDescricao = matcher.start();

            boolean found = matcher.find();

            if (found) {
                fimDescricao = matcher.start();

                String descricao = null;


                descricao = entrada.substring(inicioDescricao, fimDescricao).trim();

                // local
                resposta.setLocalDaLigacao(descricao);

                String duracao = matchTempo.group();
                inicioPlano = matchTempo.end();

                if(matchTempo.find()) {
                    duracao = matchTempo.group();
                    inicioPlano = matchTempo.end();
                }

                if (aCobrar) {
                    resposta.setDuracaoLigacaoACobrarSegundos(EntradaAbstrata.getDuracaoLigacaoSegundos(duracao));
                } else {
                    resposta.setDuracaoLigacaoSegundos(EntradaAbstrata.getDuracaoLigacaoSegundos(duracao));
                }
            } else {
                resposta.setLocalDaLigacao("");
                resposta.setDuracaoLigacaoSegundos(60);
            }



        }

        if (destino == null) {
            destino = new Telefone("", true);
        }
        //destino
        resposta.setDestino(destino);

        //num misterioso
        resposta.setNumeroMisterioso(entrada.substring(0, entrada.indexOf(" ")));

        //data e hora
        Matcher matcher = data.matcher(entrada);
        boolean b = matcher.find();
        String date = "";
        if (b) {
            date = matcher.group();
            matcher = tempo.matcher(entrada);
            b = matcher.find();

            String hour = null;

            if (b) {
                hour = matcher.group();
            } else {
                hour = "00:00:00";
            }
            resposta.setDataOrigemLigacao(QuebraStringTIM.createDate(date, hour));
        } else {
            resposta.setDataOrigemLigacao(null);
        }



        //valor
        matcher = custo.matcher(entrada);
        b = matcher.find();

        /*if (isLigacao) {
        int posFimPlano = matcher.start();

        String plano = entrada.substring(inicioPlano, posFimPlano).trim();

        if (aCobrar) {
        plano += " A Cobrar";
        }

        resposta.setTipoDeLigacao(plano);

        }*/

        if (!b) {
            resposta.setCusto(null);
        } else {
            String val = matcher.group().replace(',', '.');
            val = val.replace(" ", "");

            Double preco = Double.parseDouble(val);
            resposta.setCusto(preco);

            if (isLigacao) {
                if (preco == 0) {
                    tipoLigacao += " Franqueada";
                }
                // tipo e plano, iguais neste caso pq o Leandro pediu
                resposta.setPlanoLigacao(tipoLigacao);
                resposta.setTipoDeLigacao(tipoLigacao);

            }

        }



        resposta.setNumeroDeOrigem(numeroDeOrigem);

        return resposta;

    }

    public static EntradaAbstrata quebraStringOI(String entrada, Telefone numeroDeOrigem) {

        entrada = entrada.trim() + " ";

        String[] valores = entrada.split(";");

        if (valores.length != 7) {
            throw new IllegalArgumentException("Entrada invalida. A entrada deve"
                    + "conter 7 argumentos separados por ';'.");
        }


        // Valores que vem no arquivo
        String numeroMisterioso = valores[0];
        String miolo = valores[1].trim();
        String valor = valores[3].trim().replace(",", ".");
        String numEstranho = valores[4].trim();
        String cidadeDestino = valores[5].trim();
        //


        ////////////////////////////////////////////////////////////////////
        // Miolo

        Matcher matchOutrasCobrancas = outrasCobrancas.matcher(miolo);

        // Nao e ligacao
        if (!matchOutrasCobrancas.find()) {

            EntradaAbstrata outraCorabnca = new OutrasCobrancas();

            outraCorabnca.setCusto(0.00);
            outraCorabnca.setDataOrigemLigacao(null);
            outraCorabnca.setDestino(null);
            outraCorabnca.setDuracaoLigacaoACobrarSegundos(null);
            outraCorabnca.setDuracaoLigacaoSegundos(null);
            outraCorabnca.setImposto(null);
            outraCorabnca.setLocalDaLigacao(miolo.substring(10).trim());
            outraCorabnca.setNumeroDeOrigem(numeroDeOrigem);
            outraCorabnca.setNumeroMisterioso(numeroMisterioso);
            outraCorabnca.setOutroNumeroMisterioso(null);
            outraCorabnca.setPlanoLigacao(null);
            outraCorabnca.setTipoDeLigacao(null);

            return outraCorabnca;

        }

        StringTokenizer tokenizer = new StringTokenizer(miolo);
        String dataLigacao = tokenizer.nextToken();
        String tipoDeLigacao = tokenizer.nextToken();

        String localDaLigacao = "";
        String aux = "";

        while (tokenizer.hasMoreTokens()) {
            aux = tokenizer.nextToken();

            Matcher matcher = telefone.matcher(aux);
            if (matcher.find()) {
                break;
            }
            localDaLigacao += aux;
        }

        Telefone destino = new Telefone(aux.substring(0, 4), aux.substring(5));
        String horaLigacao = tokenizer.nextToken();
        String duracaoLigacao = tokenizer.nextToken();

        /////////////////////////////////////////////////////////////////////

        EntradaAbstrata ligacao = new Ligacao();

        {
            ligacao.setCusto(Double.parseDouble(valor));
            ligacao.setDataOrigemLigacao(EntradaAbstrata.criaDate(dataLigacao, horaLigacao));
            ligacao.setDestino(destino);
            ligacao.setDuracaoLigacaoACobrarSegundos(null);
            ligacao.setDuracaoLigacaoSegundos(EntradaAbstrata.getDuracaoLigacaoSegundos(duracaoLigacao));
            ligacao.setImposto(numEstranho);
            ligacao.setLocalDaLigacao(localDaLigacao);
            ligacao.setNumeroDeOrigem(numeroDeOrigem);
            ligacao.setNumeroMisterioso(numeroMisterioso);
            ligacao.setOutroNumeroMisterioso("");
            ligacao.setPlanoLigacao(valores[6]);
            ligacao.setTipoDeLigacao(tipoDeLigacao);
        }

        return ligacao;

    }

    public static EntradaAbstrata quebraStringOIFixo(String entrada, Telefone numeroDeOrigem, boolean cobrar) {

        StringTokenizer tokenizer = new StringTokenizer(entrada);
        String numeroMisterioso = tokenizer.nextToken();
        String data = tokenizer.nextToken();

        String restoEntrada = "";

        while (tokenizer.hasMoreTokens()) {
            restoEntrada += tokenizer.nextToken() + " ";
        }

        Matcher matchLigacao = outrasCobrancasFixo.matcher(restoEntrada);

        if (matchLigacao.find()) {

            String descricao = restoEntrada.substring(0, matchLigacao.start());
            String foneHoraDuracao = matchLigacao.group();

            tokenizer = new StringTokenizer(restoEntrada.substring(matchLigacao.end()));

            String[] restoLigacao = new String[tokenizer.countTokens()];

            for (int i = 0; i < restoLigacao.length; i++) {
                restoLigacao[i] = tokenizer.nextToken();
            }

            tokenizer = new StringTokenizer(foneHoraDuracao);
            String ddd = tokenizer.nextToken();
            String fone = tokenizer.nextToken();
            String hora = tokenizer.nextToken();
            String duracao = tokenizer.nextToken();

            if (duracao.matches("[0-9]{4}:[0-9]{2}")) {

                StringBuilder sb = new StringBuilder(duracao);
                sb.insert(2, ":");
                duracao = sb.toString();
            }

            Telefone destino = new Telefone(ddd, fone.split("-")[0], fone.split("-")[1]);



            EntradaAbstrata ligacao = new Ligacao();

            {


                ligacao.setDataOrigemLigacao(EntradaAbstrata.criaDate(data, hora));
                ligacao.setDestino(destino);

                if (cobrar) {
                    ligacao.setDuracaoLigacaoACobrarSegundos(EntradaAbstrata.getDuracaoLigacaoSegundos(duracao));
                    ligacao.setDuracaoLigacaoSegundos(null);
                } else {
                    ligacao.setDuracaoLigacaoACobrarSegundos(null);
                    ligacao.setDuracaoLigacaoSegundos(EntradaAbstrata.getDuracaoLigacaoSegundos(duracao));
                }

                ligacao.setImposto("");
                ligacao.setLocalDaLigacao(descricao);
                ligacao.setNumeroDeOrigem(numeroDeOrigem);
                ligacao.setNumeroMisterioso(numeroMisterioso);
                ligacao.setOutroNumeroMisterioso("");

                if (cobrar) {
                    ligacao.setTipoDeLigacao("Cobrar " + ddd);
                } else {
                    ligacao.setTipoDeLigacao(ddd);
                }


                if (restoLigacao.length == 3) {
                    ligacao.setPlanoLigacao(restoLigacao[1]);
                } else {
                    ligacao.setPlanoLigacao("");
                }

                Pattern patternCusto = Pattern.compile("[0-9]+,[0-9]{2}");

                String custo = "";

                for (int i = restoLigacao.length - 1; i >= 0; i--) {
                    Matcher m = patternCusto.matcher(restoLigacao[i]);
                    if (m.find()) {
                        custo = m.group().replace(',', '.');
                        break;
                    }
                }

                double valor = Double.parseDouble(custo);

                if (valor == 0.0) {
                    String temp = ligacao.getPlanoLigacao();
                    temp += " franqueada";
                    ligacao.setPlanoLigacao(temp);
                }

                ligacao.setCusto(valor);

            }

            return ligacao;

        } else {

            String[] valores = restoEntrada.split(" ");
            Pattern patternCusto = Pattern.compile("[0-9]+,[0-9]{2}");

            Matcher m = patternCusto.matcher(restoEntrada);

            String custo = "";

            if (m.find()) {
                custo = m.group().replace(',', '.');
            } else {
                custo = "0";
            }





            EntradaAbstrata outraCorabnca = new OutrasCobrancas();

            outraCorabnca.setCusto(Double.parseDouble(custo));
            outraCorabnca.setDataOrigemLigacao(null);
            outraCorabnca.setDestino(null);
            outraCorabnca.setDuracaoLigacaoACobrarSegundos(null);
            outraCorabnca.setDuracaoLigacaoSegundos(null);
            outraCorabnca.setImposto(null);
            outraCorabnca.setLocalDaLigacao(restoEntrada.trim());
            outraCorabnca.setNumeroDeOrigem(numeroDeOrigem);
            outraCorabnca.setNumeroMisterioso(numeroMisterioso);
            outraCorabnca.setOutroNumeroMisterioso(null);
            outraCorabnca.setPlanoLigacao(null);
            outraCorabnca.setTipoDeLigacao(null);

            return outraCorabnca;
        }

    }

    public static Date createDate(String dataOrigem) {

        Calendar calendar = Calendar.getInstance();
        calendar.set(Integer.parseInt(dataOrigem.substring(6)),
                Integer.parseInt(dataOrigem.substring(3, 5)) - 1,
                Integer.parseInt(dataOrigem.substring(0, 2)));
        return calendar.getTime();
    }
    public static Pattern patternLigacoes = Pattern.compile("liga..es");

    public static EntradaAbstrata quebraStringPlanoOIContaTotal(Telefone origem, String line) {

        Pattern patternCusto = Pattern.compile("(-[ ]?)?[0-9]+[,][ ]?[0-9]{2}");

        EntradaAbstrata entrada = new Ligacao();

        entrada.setNumeroDeOrigem(origem);
        entrada.setDestino(new Telefone("", true));
        entrada.setDuracaoLigacaoSegundos(60);

        Matcher matchLigacoes = patternLigacoes.matcher(line.toLowerCase());

        if (matchLigacoes.find()) {
            return null;
        }

        if (line.contains("Mensagens") || line.contains("Outros Servi")) {
            return null;
        }

        Matcher matchCusto = patternCusto.matcher(line);

        matchCusto.find();

        String valorLig = matchCusto.group();

        String tipo = line.replace(valorLig, "");

        entrada.setTipoDeLigacao(tipo);
        entrada.setPlanoLigacao(tipo);

        valorLig = valorLig.replace(',', '.');
        valorLig = valorLig.replace(" ", "");

        double custo = Double.parseDouble(valorLig);

        entrada.setCusto(custo);


        return entrada;

    }
}
